package h0712;

import java.util.Scanner;
/**
  * @description 分披萨
  * @author 不知名帅哥
  * @date 2024/7/12 22:52
  * @version 1.0
*/
public class AllocatePizza {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        //求"吃货"能分得的最大的披萨大小的总和。
        int[] pizza = new int[N];
        for (int i = 0; i < N; i++) {
            pizza[i] = sc.nextInt();
        }

        //dp[i][j] 表示在子数组 pizza[i] 到 pizza[j] 范围内，当前玩家能获得的最大披萨块数。
        int[][] dp = new int[N][N];


        for (int length = 1; length <= N; length++) {
            for (int i = 0; i < N; i++) {
                int j = (i + length - 1) % N;
                if (length == 1) {
                    dp[i][j] = pizza[i];
                } else {
                    int nextI = (i + 1) % N;
                    int prevJ = (j - 1 + N) % N;
                    dp[i][j] = Math.max(
                            //吃货拿了最左边披萨后，馋嘴有可能从继续从最左边拿，就是dp[(i + 2) % N][j]。
                            //也有可能从右边拿，就是dp[nextI][prevJ]。然后从中取最小值(尽可能使得馋嘴取得最小)。
                            pizza[i] + Math.min(dp[(i + 2) % N][j], dp[nextI][prevJ]),
                            //吃货拿了最右边披萨后，馋嘴有可能从继续从最右边拿，就是dp[i][(j - 2) % N]。
                            //也有可能从左边拿dp[nextI][prevJ]。
                            pizza[j] + Math.min(dp[i][(j - 2 + N) % N], dp[nextI][prevJ])
                    );
                }
            }
        }

        int maxPizza = 0;
        for (int i = 0; i < N; i++) {
            maxPizza = Math.max(maxPizza, dp[i][(i + N - 1) % N]);
        }

        System.out.println(maxPizza);
    }
    //选择过程解释
    //
    //当前玩家选择最左边的披萨块 pizza[i]：
    //
    //当前玩家获得 pizza[i]。
    //然后，问题变成对手在子数组 [i+1, j] 范围内的选择。
    //由于对手也会采取最优策略，我们需要考虑对手在 [i+1, j] 范围内的选择可能会影响我们下一步的得分。因此，我们考虑对手会使我们在下一步的选择变得最糟糕。
    //具体来说，如果对手在 [i+1, j] 范围内选择最左边的 pizza[i+1]，当前玩家下一步会面对子数组 [i+2, j]，或者对手选择最右边的 pizza[j]，当前玩家下一步会面对子数组 [i+1, j-1]。
    //当前玩家选择最右边的披萨块 pizza[j]：
    //
    //当前玩家获得 pizza[j]。
    //然后，问题变成对手在子数组 [i, j-1] 范围内的选择。
    //同理，我们考虑对手会使我们在下一步的选择变得最糟糕。
    //具体来说，如果对手在 [i, j-1] 范围内选择最左边的 pizza[i]，当前玩家下一步会面对子数组 [i+1, j-1]，或者对手选择最右边的 pizza[j-1]，当前玩家下一步会面对子数组 [i, j-2]。
}
